Computer systems (and related devices) typically model three-dimensional images using a mosaic-like approach where each image is partitioned into a collection of individual points, lines and polygons. These points, lines and polygons are know as primitives and a single image may require thousands, or even millions, of primitives. The definition of an image may also include one or more graphics attributes. Each attribute defines a property that affects how the primitives within an image will appear. Examples of attributes include attributes that define light sources and attributes that define textures.
The primitives and attributes used to describe three-dimensional images are transformed into pixel values using a process known as rendering. The rendering process is typically partitioned into a series of tasks that are arranged as a sequential pipeline. Early tasks within this pipeline perform transformations on the primitives included within the image being rendered. For example, a task may be used to transform primitives to reflect the presence of a light source. The operation of these tasks is controlled by the attributes included within the image definition. Thus, operation of a lighting task is controlled by attributes that describe light sources.
The transformation tasks are followed by one or more rasterization tasks. The rasterization tasks transform each primitive into a collection of pixel values. The pixel values are stored in a memory storage device known as a frame buffer. Rasterization tasks, like transformation tasks, operate under control of the attributes included within the image definition. As an example, operation of a texturing task is controlled by attributes that describe image textures. In some ways, rasterization tasks resemble transformation tasks. Unlike transformation tasks, however, the effect of rasterization tasks is pixel oriented. This distinguishes these tasks from transformation tasks because the latter generally operate to transform primitives, not pixels.
Multipass rendering is a technique that builds upon the basic rendering mechanism just described. For multipass rendering, the same pipeline is used to repeatedly render selected primitives within an image. Each iteration of this process is referred to as a pass. During each pass, the pipeline performing the rendering process is reconfigured to reflect a different set of attributes. This alters the rendering effect produced by each successive pass. As an example, successive passes may specify different light sources or different textures. In this way, multipass rendering allows more complex sequences of tasks to be used during image creation. The net effect is to increase image quality and complexity. This makes multipass rendering especially important when photo-realistic three-dimensional images are required.
Unfortunately, creating images using multipass rendering tends to be relatively time consuming. One method for expediting multipass rendering is to divide the primitives within an image into small groups. These groups are then processed on a group-by-group basis. Rendering of preceding groups is completed through each pass before rendering of following groups initiates. Ordering multipass rendering on a primitive-by-primitive basis increases the locality of memory accesses within the frame buffer and within the host computer. This increases frame buffer efficiency by reducing DRAM page misses. Increased locality also increases the effectiveness of host and frame buffer cache memories.
Unfortunately, ordering multipass rendering on a group-by-group basis increases the frequency of pipeline reconfiguration. This follows because the pipeline must be repeatedly reconfigured to reflect the entire sequence of passes each time a new group is rendered. The process of pipeline reconfiguration may be time consuming--especially in the case of deep pipelines, involving multiple tasks. In practice, the time spent performing pipeline reconfiguration may partially, or fully, offset the efficiency gained by rendering on a group-by-group basis. As a result, there is a need for rendering methods that exploit the memory locality associated with rendering on a group-by-group basis without the inefficiency associated with repeated pipeline reconfigurations.